JAVA

javaIO流

　　javaIO流….笔记

流向区分

　　应当以程序或者内存为参照物，(从文件或屏幕等)往内存中读入叫做输入流，反之输出流。

数据类型区分

　　字节流和字符流，现有的字节流，后来为了方便文本数据操作，才有的字符流，java中一个字符占两个字节。

  • 一般是默认按照数据类型分类的，不是流向。

基类

　　字节流的基类：InputStream,outputStream
　　字符流的基类：Reader,Writer

FileOutputStream & FileInputStream

  • 往文件中读写数据就用FileOutputStream & FileInputStream

  • 向文件写入数据

    1
    2
    3
    4
    5
    6
    7
    8
    //创建字节输出流对象,分三步，注意try catch包裹
    //创建字节输出流对象
    FileOutputStream fos=new  FileOutputStream("fos.txt");//fos就像一条水管连接到文件上
    //写数据
    fos.write("hello,IO".getBytes());//调用write，数据就像水流顺着水管到文件中
    //释放资源
    //关闭文件输出流并释放与此流有关的资源
    fos.close();

  • 不同系统，换行不同
    　　Windows:\r\n
    　　linux:\n
    　　mac:\r

  • 实现数据追加

    1
    2
    //第二个为true时，在末尾处追加
    FileOutputStream(String name, boolean append)

  • 加入异常处理的字节输出流

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    FileOutputStream fos=null;
    try{
    	fos=new FileOutputStream("fos.txt");
    	fos.write("java".getBytes());
    }catch(FileNodFoundException e){
    	e.printStackTrace();
    }catch(IOException e){
    	e.printStackTrace();
    }finally{
    	//如果fos不是null，才close
    	if(fos!=null){
    		try{
    			fos.close();
    		}catch(IOException e){
    			e.printStackTrace();
    		}
    	}
    }

  • FileInputStream文件的字节读入流

  • 读入流需要有文件，输出流会自动创建
    1
    2
    3
    4
    5
    6
    FileInputStream 从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。 
    FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
     int read() //每读一个字节会自动往下移一个位置,如果已到达文件末尾，则返回 -1。 
              从此输入流中读取一个数据字节。 
     int read(byte[] b) 
              从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
1
2
3
4
5
6
7
8
9
10
11
//也是需要三步
//以下代码只能读英文，中文会乱码
//创建输入流对象
FileInputStream fis=new FileOutputStream("fis.txt");
//读入字节
int by=0;
while((by=fis.read())!=-1){
	System.out.print((char)by);
}
//释放资源
fis.close();

  • 中文处理
    　　一个中文字符分为两个字节，第一个字节ASCII肯定是负数，第二个不一定。只需见一个负数，就跟后面一个字节组成一个字符。

  • 一次读取一个字节数组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    import java.io.FileInputStream;
    import java.io.IOException;

    /***
     * 一次读取一个字节数组：int read(byte[]b); 返回值是实际读取的字节个数
     * 
     * @author TWS
     *
     */

    public class CopyFiledemo2 {
    	public static void main(String[] args) throws IOException {
    		FileInputStream fis = new FileInputStream("fis.txt");
    		byte[] bys = new byte[5];
    		int len = 0;
    		while ((len = fis.read(bys)) != -1) {
    			System.out.print(new String(bys, 0, len));
    		}
    		fis.close();
    		
    	}
    }

BufferedOutputStream & BufferedInputStream

  • 缓冲区类，其作用是缓冲，相当于一个水杯。
    1
    2
    3
    4
    BufferedInputStream(InputStream in) 
              创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。 
    BufferedInputStream(InputStream in, int size) 
              创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;

/**
 * 字节流四种方式复制文件：
 * 基本字节流一次一个字节，一次一个数组
 * 高效字节流一次一个字节，一次一个数组
 * @author TWS
 *
 */

public class CopyFiledemo3 {
	public static void main(String[] args) throws IOException{
		long start=System.currentTimeMillis();
		//method1("F:\\教程\\java视频\\day20\\avi\\20.01_IO流(递归概述和注意事项).avi","1.avi");
		method2("F:\\教程\\java视频\\day20\\avi\\20.01_IO流(递归概述和注意事项).avi","1.avi");
		long end=System.currentTimeMillis();
		System.out.println("共耗时："+(end-start));
	}

	//字节缓冲区方式
	public static void method1(String string, String string2) throws IOException {
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream(string));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(string2));
		byte[] bys=new byte[1024];
		int len=0;
		while((len=bis.read(bys))!=-1){
			bos.write(bys, 0, len);
		}
		bos.close();
		bis.close();
	}
	
	//用字符缓冲区方式，移动视频时不如上一种高效
	public static void method2(String string, String string2) throws IOException {
		BufferedReader br=new BufferedReader(new FileReader(string));
		BufferedWriter bw=new BufferedWriter(new FileWriter(string2));
		char[] bys=new char[1024];
		int len=0;
		while((len=br.read(bys))!=-1){
			bw.write(bys, 0, len);
		}
		br.close();
		bw.close();
			
	}
}

字符流类似

  • 学会了字节流，字符流类似
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    字节流：
    		InputStream
    			FileInputStream
    			BufferedInputStream
    		Outputstream
    			FileOutputStream
    			BufferedOutputStream
    字符流：
    		Reader
    			FileReader
    			BufferedReader
    		Writer
    			FileWriter
    			BufferedWriter

编码表

ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符号。
GB18030：GBK的取代版本
BIG-5码 ：通行于台湾、香港地区的一个繁体字编码方案，俗称“大五码”。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8：最多用三个字节来表示一个字符。

UTF-8不同，它定义了一种“区间规则”，这种规则可以和ASCII编码保持最大程度的兼容：
它将Unicode编码为00000000-0000007F的字符，用单个字节来表示
它将Unicode编码为00000080-000007FF的字符用两个字节表示
它将Unicode编码为00000800-0000FFFF的字符用3字节表示

IO流小结

字符缓冲流读写字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//最为推荐的一种方式
// 字符缓冲流一次读写一个字符串
	private static void method5(String srcString, String destString)
			throws IOException {
		BufferedReader br = new BufferedReader(new FileReader(srcString));
		BufferedWriter bw = new BufferedWriter(new FileWriter(destString));

		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();
	}

欢迎与我分享你的看法。
转载请注明出处：http://taowusheng.cn/
微博：寒枫–0-0–
知乎：https://www.zhihu.com/people/tao-wu-sheng
豆瓣：YIFEI